package com.lwh.videopicplayer.utils;


import android.content.Context;
import android.os.Environment;
import android.os.storage.StorageManager;
import android.util.Log;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.List;

public class Utils {

    /**
     * 判断字符串是否为空
     *
     * @param obj 要判断的字符串
     * @return 是否为空
     */
    public static boolean isEmpty(Object obj) {
        if (null == obj || "".equals(obj)) {
            return true;
        } else {
            return false;
        }
    }
    public static boolean isEmpty(List obj) {
        if (null == obj || "".equals(obj)||obj.size()==0) {
            return true;
        } else {
            return false;
        }
    }
    /**
     * 读取SD路径，返回路径集合
     * @return
     */
    public static File getSD() {
        File sdDir= null;
        boolean sdCardExist = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);//判断sd卡是否存在
        if(sdCardExist){
            //获取根节点
            sdDir = Environment.getExternalStorageDirectory();
        }
        return sdDir;
    }

    /**
     * 递归删除目录
     * @param dir
     * @return
     */
    public static boolean deleteDir(File dir) {
        if (dir.isDirectory()) {
            String[] children = dir.list();
            //递归删除目录中的子目录下
            for (int i=0; i<children.length; i++) {
                boolean success = deleteDir(new File(dir, children[i]));
                if (!success) {
                    return false;
                }
            }
        }
        // 目录此时为空，可以删除
        Log.i("del","dir=="+dir.getAbsolutePath());
        return dir.delete();
    }
    //重点理解，这是一个递归方法，会不断来回调用本身，但是所有获得的数据都会存放在集合files里面
    public static void longErgodic(File file, List files) {

        //.listFiles()方法的使用
        //把文件夹的所有文件（包括文件和文件名）都放在一个文件类的数组里面
        File[] fillArr=file.listFiles();

        //如果是一个空的文件夹
        if (fillArr==null) {
            //后面的不执行，直接返回
            return;
        }

        //如果文件夹有内容,遍历里面的所有文件（包括文件夹和文件），都添加到集合里面
        for (File file2 : fillArr) {

            //如果只是想要里面的文件或者文件夹或者某些固定格式的文件可以判断下再添加
            files.add(file2.getAbsolutePath());

            //添加到集合后，在来判断是否是文件夹，再遍历里面的所有文件
            //方法的递归
            longErgodic(file2, files);
        }
    }
    //重点理解，这是一个递归方法，会不断来回调用本身，但是所有获得的数据都会存放在集合files里面
    public static void zjlongErgodic(File file, List files) {

        File[] fillArr=file.listFiles();

        if (fillArr==null) {

            return;
        }

        for (File file2 : fillArr) {
            files.add(file2.getAbsolutePath());
        }
    }
    /**
     * 获取文件夹的大小
     * @param file
     * @return
     */
    public static long getTotalSizeOfFilesInDir(final File file) {
        if (file.isFile())
            return file.length();
        final File[] children = file.listFiles();
        long total = 0;
        if (children != null)
            for (final File child : children)
                total += getTotalSizeOfFilesInDir(child);
        return total;
    }

    public static boolean isImg(String ab) {

       return ab.endsWith(".jpg") ||ab.endsWith(".png")||ab.endsWith(".bmp");
    }

    public static boolean isMP3(String ab) {
        return ab.endsWith(".mp3");
    }

    public static boolean isVideo(File files) {
        return files.getAbsolutePath().endsWith(".mp4");
    }

    public interface callBack{
        void start(long total);
        void copy(long curtotal);
        void complate(boolean result,long total);
        void erro(long total);
    }
    // 复制文件
    public static boolean copyFile(File oldfile,File targetFile,callBack mcallback) {
        // 新建文件输入流并对它进行缓冲
        FileInputStream input = null;
        if(oldfile.isDirectory()){
            targetFile.mkdirs();
            return true;
        }
        long length = oldfile.length();
        try {
            mcallback.start(length);
            input = new FileInputStream(oldfile);

            BufferedInputStream inBuff=new BufferedInputStream(input);

            // 新建文件输出流并对它进行缓冲
            FileOutputStream output = new FileOutputStream(targetFile);
            BufferedOutputStream outBuff=new BufferedOutputStream(output);

            // 缓冲数组
            byte[] b = new byte[1024 * 1024 * 5];
            int len;
            while ((len =inBuff.read(b)) != -1) {
                outBuff.write(b, 0, len);
                mcallback.copy(len);
            }
            outBuff.flush();
            //关闭流
            inBuff.close();
            outBuff.close();
            output.close();
            input.close();
        } catch (Exception e) {
            //e.printStackTrace();
            Log.i("check", "e=="+e);
            mcallback.erro(length);
            return false;
        }
        mcallback.complate(true,length);
        return true;

    }


    // 复制文件
    public static boolean copyFile2(File oldfile,File targetFile,callBack mcallback) {
        // 新建文件输入流并对它进行缓冲
        FileInputStream input = null;
        if(oldfile.isDirectory()){
            targetFile.mkdirs();
            return true;
        }
        long length = oldfile.length();
        try {
            mcallback.start(length);
            input = new FileInputStream(oldfile);

            BufferedInputStream inBuff=new BufferedInputStream(input);

            // 新建文件输出流并对它进行缓冲
            FileOutputStream output = new FileOutputStream(targetFile);
            BufferedOutputStream outBuff=new BufferedOutputStream(output);
            FileChannel fileChannelOutput = null;
            FileChannel fileChannelInput = null;

            fileChannelOutput = output.getChannel();
            fileChannelInput = input.getChannel();
            ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024 * 1);

            int len;
            while (fileChannelInput.read(buffer) != -1) {
                buffer.flip();
                len = fileChannelOutput.write(buffer);
                mcallback.copy(len);
                buffer.clear();
            }

            outBuff.flush();
            output.flush();

            fileChannelOutput.close();
            fileChannelInput.close();

            //关闭流
            inBuff.close();
            outBuff.close();
            output.close();
            input.close();

        } catch (Exception e) {
            //e.printStackTrace();
            Log.i("check", "e=="+e);
            mcallback.erro(length);
            return false;
        }
        mcallback.complate(true,length);
        return true;

    }

    public static void setSystemProperty(String key, String value) {
        try {
            Class clz = Class.forName("android.os.SystemProperties");
            Method set = clz.getDeclaredMethod("set", String.class, String.class);
            set.invoke(clz, key, value);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static String getSystemProperty(String key, String defValue) {
        try {
            Class clz = Class.forName("android.os.SystemProperties");
            Method get = clz.getDeclaredMethod("get", String.class, String.class);
            return String.valueOf(get.invoke(clz, key, defValue));
        } catch (Exception e) {
            e.printStackTrace();
            return defValue;
        }
    }


}
